#include <sstream>
#include "PowerSystemStabilizerDynamics.hpp"
#include "PssPTIST3.hpp"

#include "PU.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "PU.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "Boolean.hpp"
#include "Simple_Float.hpp"
#include "Simple_Float.hpp"
#include "Simple_Float.hpp"

using namespace CIMPP;

PssPTIST3::PssPTIST3() {};

PssPTIST3::~PssPTIST3() {};





































bool assign_PssPTIST3_m(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->m;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_tf(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->tf;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_tp(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->tp;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_t1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->t1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_t2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->t2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_t3(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->t3;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_t4(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->t4;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_k(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->k;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_dtf(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->dtf;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_dtc(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->dtc;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_dtp(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->dtp;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_t5(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->t5;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_t6(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->t6;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_a0(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->a0;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_a1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->a1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_a2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->a2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_b0(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->b0;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_b1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->b1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_b2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->b2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_a3(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->a3;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_a4(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->a4;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_a5(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->a5;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_b3(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->b3;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_b4(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->b4;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_b5(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->b5;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_athres(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->athres;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_dl(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->dl;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_al(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->al;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_lthres(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->lthres;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_pmin(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->pmin;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_isw(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->isw;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_nav(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->nav;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_ncl(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->ncl;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssPTIST3_ncr(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssPTIST3* element = dynamic_cast<PssPTIST3*>(BaseClass_ptr1)) {
                buffer >> element->ncr;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

namespace CIMPP {
	BaseClass* PssPTIST3_factory() {
		return new PssPTIST3;
	}
}

void PssPTIST3::addConstructToMap(std::unordered_map<std::string, BaseClass* (*)()>& factory_map) {
	factory_map.insert(std::make_pair(std::string("cim:PssPTIST3"), &PssPTIST3_factory));
}

void PssPTIST3::addPrimitiveAssignFnsToMap(std::unordered_map<std::string, assign_function>& assign_map) {
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.m"), &assign_PssPTIST3_m));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.tf"), &assign_PssPTIST3_tf));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.tp"), &assign_PssPTIST3_tp));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.t1"), &assign_PssPTIST3_t1));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.t2"), &assign_PssPTIST3_t2));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.t3"), &assign_PssPTIST3_t3));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.t4"), &assign_PssPTIST3_t4));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.k"), &assign_PssPTIST3_k));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.dtf"), &assign_PssPTIST3_dtf));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.dtc"), &assign_PssPTIST3_dtc));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.dtp"), &assign_PssPTIST3_dtp));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.t5"), &assign_PssPTIST3_t5));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.t6"), &assign_PssPTIST3_t6));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.a0"), &assign_PssPTIST3_a0));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.a1"), &assign_PssPTIST3_a1));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.a2"), &assign_PssPTIST3_a2));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.b0"), &assign_PssPTIST3_b0));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.b1"), &assign_PssPTIST3_b1));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.b2"), &assign_PssPTIST3_b2));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.a3"), &assign_PssPTIST3_a3));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.a4"), &assign_PssPTIST3_a4));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.a5"), &assign_PssPTIST3_a5));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.b3"), &assign_PssPTIST3_b3));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.b4"), &assign_PssPTIST3_b4));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.b5"), &assign_PssPTIST3_b5));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.athres"), &assign_PssPTIST3_athres));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.dl"), &assign_PssPTIST3_dl));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.al"), &assign_PssPTIST3_al));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.lthres"), &assign_PssPTIST3_lthres));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.pmin"), &assign_PssPTIST3_pmin));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.isw"), &assign_PssPTIST3_isw));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.nav"), &assign_PssPTIST3_nav));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.ncl"), &assign_PssPTIST3_ncl));
	assign_map.insert(std::make_pair(std::string("cim:PssPTIST3.ncr"), &assign_PssPTIST3_ncr));
}

void PssPTIST3::addClassAssignFnsToMap(std::unordered_map<std::string, class_assign_function>& assign_map) {
																																		}

const char PssPTIST3::debugName[] = "PssPTIST3";
const char* PssPTIST3::debugString()
{
	return PssPTIST3::debugName;
}

const BaseClassDefiner PssPTIST3::declare()
{
	return BaseClassDefiner(PssPTIST3::addConstructToMap, PssPTIST3::addPrimitiveAssignFnsToMap, PssPTIST3::addClassAssignFnsToMap, PssPTIST3::debugName);
}


